home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / libs / knowhow4 / graphics.txt < prev    next >
Text File  |  1994-10-22  |  16KB  |  351 lines
  1. /*
  2. █████████████████████████████████████████████████████████████████████████████
  3. ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
  4. ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓ KNOW-HOW.GRAPHICS ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
  5. ▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
  6. █████████████████████████████████████████████████████████████████████████████
  7.  
  8. This text contain complete description of KNOW_HOW.GRAPHICS 5.0x, the
  9. product in the 5th version of library. It provide the following features:
  10.     a) Using common code for any graphics library. It is realized now for
  11.        BGI and for Windows GDI. It is not difficult to add few lines of
  12.        code to use any other library, if it support basical operations
  13.        (lineto, moveto etc.)
  14.     b) Scrolling, Zooming, mirror reflection of image, rotations and even
  15.        complex rotations of image. Saying "complex rotations" I mean drawing
  16.        of the picture, rotated around x,y to alpha, then (result) around
  17.        x1,y1 to beta and so on. BGI fonts could be rotated too, filled BGI
  18.        fonts are also available (not all BGI font could be filled, of course).
  19. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  20. Additional (and very powerfull) features are available if KNOW-HOW.GRAPHICS
  21. is used together with KNOW-HOW.SLANG. SLANG is BASIC-like language, designed
  22. as CPP class. Its child classes could have additional operators, so
  23. KNOW-HOW.SLANG.GRAPHICS is the BASIC with access to drawing tools of current
  24. product. It provide to user the possibility to load graphical resourses
  25. (DOS or Windows, or other if he add some code) and interprete them in
  26. run-time. There are very many applications of this tool, like run-time
  27. changeable GUI, maketing (without stage of compilation) of BGI, GDI and so on
  28. applications, vector drawing tools (KNOW-HOW.VECTOR is the ready-to-use
  29. product of this type). Together with BASIC math. functions it could also be
  30. used for data plotting, spreadsheets and so on.
  31.  
  32. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  33. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ SERVICE FILES ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  34. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  35.  
  36. ▐▐▐▐▐▐▐ File SIMPLE.H contains some simplifications for often used names.
  37. Complete listing:
  38.  
  39. ▐ #ifndef __SIMPLE_H_
  40. ▐ #define __SIMPLE_H_
  41. ▐
  42. ▐ typedef unsigned char uchar;
  43. ▐ typedef unsigned long ulong;
  44. ▐ typedef int bool;
  45. ▐
  46. ▐ #define TRUE  1
  47. ▐ #define FALSE 0
  48. ▐ #define ON   TRUE
  49. ▐ #define OFF  FALSE
  50. ▐
  51. ▐ #endif __SIMPLE_H_
  52. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  53. -----------------------------------------------------------------------------
  54. ▐▐▐▐▐▐▐ File GEOM.H contains geometry of KNOW-HOW. It defines geom. objects
  55. in C++ manner: loc(x, y) defines point, rect(x1, y1, x2, y2) - rectangle and
  56. so on.
  57. For example, instead of call to f(int x, int y) we could call f(loc l), where
  58. loc is defined in GEOM.H as
  59. ▐ struct loc
  60. ▐ { int X,Y;
  61. ▐ .....
  62. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  63. -----------------------------------------------------------------------------
  64. ▐▐▐▐▐▐▐ Files TRIGON.H and TRIGON.CPP contains structure with the overloaded
  65. sin(int) and cos(int) functions. This functions works more quick than standart
  66. versions but are not so flexible.
  67. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  68. -----------------------------------------------------------------------------
  69. ▐▐▐▐▐▐▐ Files KH_ERROR.H and KH_ERROR.CPP are the part of KNOW-HOW error
  70. handling system. The only variable is defined: kh_error_code. Functions of
  71. KNOW-HOW or user-defined functions could change it, default value is
  72. KH_SUCCESS:
  73.  
  74. ▐ enum { KH_SUCCESS, KH_UNKNOWN_ERROR, KH_FILE_ERROR, KH_BGI_ERROR,
  75. ▐       KH_MEMORY_ERROR, KH_USER_ERROR };
  76.  
  77. This list could be continued:
  78.  
  79. ▐ enum { KH_NEW_ERROR = KH_USER_ERROR + 1, ... }
  80. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  81. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ DRAWING MODULES ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  82. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  83.  
  84. ▐▐▐▐▐▐▐ File ABS_GRAF.H contains empty shablons of functions. We could
  85. derivate classes from it not thinking about concrete graphics library we
  86. shell use. It provide common code for any DOS, Windows and so on libraries,
  87. if them include the same functions. This set is only part of Paint class's
  88. functions set, described in PAINT.H:
  89.  
  90. ▐ struct AbstractGraphics
  91. ▐    {
  92. ▐    virtual void moveto(int x, int y) {}
  93. ▐    virtual void lineto(int x, int y) {}
  94. ▐    virtual void fillpoly(int numpoints, int* polypoints) {}
  95. ▐    };
  96. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  97. -----------------------------------------------------------------------------
  98. ▐▐▐▐▐▐▐ Files BGI_FONT.H and BGI_FONT.CPP contains class, which incapsulate
  99. BGI fonts (*.chr) description.
  100.     1. BGI fonts are not documented. I use existing format.
  101.     2. Abstract (non-BGI) graphics is used for moveto, lineto, drawpoly and
  102.        fillpoly operations. It should be overloaded in child classes for
  103.        concrete graf. libraries like BGI, Windows GDI and so on.
  104.     3. BGI header have some fields, which are not absolutely necessary (for
  105.        current class). I skip them and remarks are not complete for them.
  106.     4. No facilities like "vertical text" and so on is supported.
  107.        The reason is: I suppose to use drawing extender which have rotation
  108.        possibilities in Paint class.
  109. BGI font format is documented in the remarks to code in these files. So I
  110. give here only the brief explanation. BGI use two types of commands for
  111. drawing - moveto and lineto. To define non-filled fonts I use calls to the
  112. same (virtual) functions. To draw filled fonts I use fillpoly() function.
  113. In this case lineto calls are added to points array, and moveto call stop
  114. the polygon creation and begin next one. To use filled fonts you should
  115. use fonts which are drawn as group of closed polygons. Example - 'O' char:
  116.  
  117.        ┌───────┐
  118.        │▓▓▓▓▓▓▓│
  119.        │▓┌───┐▓│
  120.        │▓│   │▓│
  121.        │▓└─┬─┘▓│
  122.        │▓▓▓│▓▓▓│
  123.        └───┴───┘
  124. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  125. -----------------------------------------------------------------------------
  126. ▐▐▐▐▐▐▐ Files PAINT.H and PAINT.CPP. In the files described previously, we
  127. have incapsulated graphics primitives like lineto, moveto, drawchar and
  128. so on. Now the additional shell is included for rotation, mirror reflection,
  129. complex rotation, zooming and scrolling. All this operations are performed
  130. with abstract graphics calls, and not depend on library which you intend
  131. to use.
  132. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  133. ------------------------- WHAT IS COMPLEX ROTATION ? ------------------------
  134. ░Rotation could be simply processed if it is single operation. To use nested
  135. ░rotations we use stack of rotations info structures. Example of complex
  136. ░rotation:
  137. ░
  138. ░     void f1(int x, int y, int alpha) { ... perform rotation ... }
  139. ░     void f2(int x, int y, int alpha) { rotate(10,10,90); f1(x, y, alpha); }
  140. ░Function f2() call rotation procedure and then call f1(), which call another
  141. ░rotation. We could a) cancel first rotation and b) add first and second
  142. ░rotations to complex transformation. KNOW-HOW.GRAPHICS make possible both
  143. ░variances.
  144. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  145. The structure RInfo is used to keep information about single rotation, and
  146. stack of RInfo's is used (if R_STACK variable is set to 1) to keep complex
  147. rotation information.
  148. ▐ struct RInfo
  149. ▐    {
  150. ▐    loc center;
  151. ▐    int angle;
  152. ▐    };
  153. ///////////////
  154. ▐ struct Stack
  155. ▐    {
  156. ▐    int used, total;
  157. ▐    RInfo* list;
  158. ▐
  159. ▐    Stack();
  160. ▐    ~Stack();
  161. ▐    void push(RInfo* r);
  162. ▐    void pop();
  163. ▐    void flash();
  164. ▐    };
  165. ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
  166. -----------------------------------------------------------------------------
  167. Class Paint give some additional facilities for any graphics library. Class
  168. does not contain calls to the concrete drawing functions - only to abstract
  169. prototypes.
  170. functions shold be overloaded in child classes for adaptation to concrete
  171. graphic interface (BGI, GDI, and so on).
  172.  
  173. The zoom and addzoom are deformation coeficients. You could use zoom in any
  174. part of program. Addzoom is used only once to set the additional deformation
  175. of the whole picture (for example if context is changed from screen to
  176. printer), for preview and so on.
  177.  
  178. ▐ class Paint : public BGI_Font
  179. ▐    {
  180. ▐    protected:
  181. ▐    loc zoom;                     // Image deformation
  182. ▐    loc add_zoom;                 // Additional deformation
  183. ▐    loc lt;                       // Scroll of part of picture
  184. ▐    loc add_scroll;               // Left - top clip of the whole picture
  185. ▐    int fill;                     // Fill flag
  186. ▐    loc center;                   // Rotation center
  187. ▐    int alpha;                    // Rotation angle
  188. ▐    bool R_STACK;                 // Use or not stack of rotations
  189. ▐    Stack* r_stack;               // Stack of rotations
  190. ▐    int mirror;
  191. ▐    public:
  192. ▐    Paint();
  193. ▐    ~Paint() { delete r_stack; }
  194. ▐
  195. ▐    loc get_add_zoom() { return add_zoom; }
  196. ▐    loc get_zoom() { return zoom; }
  197. ▐
  198. ▐    void set_mirror(int m) { mirror = m; } // X coord. if no rotation
  199. ▐    void set_stack(bool r) { R_STACK = r; r_stack->flash();
  200. ▐        rotate(loc(0, 0), 0); }
  201. ▐    void set_zoom(double x, double y) { zoom.X = x * add_zoom.X;
  202. ▐        zoom.Y = y * add_zoom.Y; }    // No out-of-range control !!!
  203. ▐    void set_add_zoom(double x, double y) { add_zoom.X = 100 * x;
  204. ▐        add_zoom.Y = 100 * y; }
  205. ▐    void set_scroll(int x, int y) { lt.X = x; lt.Y = y; }
  206. ▐    void set_add_scroll(int x, int y) { add_scroll.X = x;
  207. ▐        add_scroll.Y = y; }
  208. ▐    void rotate(loc c, int a);
  209. ▐    void set_fill(bool f) { fill = f; }
  210. ▐
  211. ▐ // Using alpha and center returns rotated coordinates
  212. ▐    loc rot(int x, int y);
  213. ▐ // Return completely transformed point: rotated, zoomed and scrolled
  214. ▐    loc transform(int x, int y);
  215. ▐    };
  216. -----------------------------------------------------------------------------
  217. ▐▐▐▐▐▐▐ Files BGIPAINT.H and BGIPAINT.CPP. Classes in these files replace
  218. calls to empty graphics primitives functions to concrete calls of functions
  219. from BGI, GDI or from other drawing libraries. The #define directives set
  220. switches on one of libraries, user should unremark one of them to use it
  221. in program:
  222. ▐ #define DOS_BGI           // Realized
  223. ▐ // #define WIN_GDI        // Realized
  224. ▐ // #define FLASH_GRAPH    // Not Realized
  225. ▐ // #define OBJECT_GRAPH   // Not Realized
  226. ▐ // ........ to be continued
  227. The alternative solution is to use Options - Compiler - Code generation -
  228.    Defines in IDE to define the necessary variable
  229.  
  230. As the example, lets look to the code for DOS BGI.
  231.  
  232. ▐ #ifdef DOS_BGI           // If we unremark line with DOS_BGI (see above)
  233. ▐ #include <graphics.h>    // Include GBI header
  234. The following structure do nonthing but replace calls to f() {} to calls
  235. to f() { ::f(); }, where ::f() is BGI function.
  236. ▐ struct To_Paint
  237. ▐     {
  238. ▐     void putpixel(int x, int y) { ::putpixel(x, y, getcolor()); }
  239. ▐     void line(int xstart, int ystart, int xend, int yend)
  240. ▐     { line(xstart, ystart, xend, yend); }
  241. ▐
  242. ▐     void moveto(int x, int y) { ::moveto(x, y); }
  243. ▐     void lineto(int x, int y) { ::lineto(x, y); }
  244. ▐     void fillpoly(int numpoints, int* polypoints)
  245. ▐     { ::fillpoly(numpoints, polypoints); }
  246. ▐     void circle(int x, int y, int radius) { ::circle(x, y, radius); }
  247. ▐     void ellipse(int x, int y, int stangle, int endangle, int xr, int yr)
  248. ▐     { ::ellipse(x, y, stangle, endangle, xr, yr); }
  249. ▐     void drawpoly(int numpoints, int far* points)
  250. ▐     { ::drawpoly(numpoints, points); }
  251. ▐     };
  252. ▐ #endif DOS_BGI
  253.  
  254. Then we combine Paint class possibilities to zoom, scroll, rotate (including
  255. complex rotations) and so on and To_Paint possibilities to output graphics
  256. primitives using different libraries.
  257.  
  258. ▐ class KH_Paint : public To_Paint, public Paint
  259. ▐     {
  260. ▐     public:
  261. ▐     KH_Paint() : Paint()   {}
  262. ▐
  263. ▐     void putpixel(int x, int y);
  264. ▐     void line(int xstart, int ystart, int xend, int yend);
  265. ▐     void lineto(int x, int y);
  266. ▐     void moveto(int x, int y);
  267. ▐     void circle(int x, int y, int radius);
  268. ▐     void ellipse(int x, int y, int stangle, int endangle, int xr, int yr);
  269. ▐     void roundrect(int left, int top, int right, int bottom, int radius);
  270. ▐
  271. ▐     void rectangle(int left, int top, int right, int bottom);
  272. ▐     void drawpoly(int numpoints, int far* points);
  273. ▐     void outtext(char far* str);
  274. ▐     };
  275.  
  276. «»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«
  277. ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ ATTENTION !!! ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
  278.     1. The set of functions of KH_Paint class will be continued, it is
  279. possible that your version contains additional functions (setcolor() is the
  280. first candidate).
  281.     2. When the Windows compatible part (class To_Paint for Windows) was
  282. designed, I find some difficulties: Windows GDI is more powerfull than DOS
  283. BGI. It is also possible that when user will try to use his graphics library
  284. he find that it have some functions which are absent in both BGI and GDI.
  285. The solution is: use KH_Paint functions if possible, I think that it is much
  286. more than enought for most cases. Another way is to add new functions to
  287. KH_Paint (KH_Paint::draw_pig() {...} and so on, and modify To_Paint for DOS
  288. and Windows), If it is not possible - use direct calls to your lovely library
  289. - and forget about the compatibility with others.
  290.     3. KH_Paint above is restricted. The real listing of 5.0 version (and of
  291. course of 5.x) is Windows GDI - oriented. It means that if BGI does not
  292. contain some of GDI features, DOS BGI version of To_Paint class try to
  293. elulate them.
  294. ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
  295. «»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«»«
  296. -----------------------------------------------------------------------------
  297. Example.
  298. I add to *.CPP files (when possible) working examples of main() functions,
  299. to run it you need only to remove remarks. In this file I illustrate only
  300. the usage of KNOW-HOW.GRAPHICS with DOS BGI, but BGIPAINT file contains
  301. also example of Windows OWL usage.
  302.  
  303. ▐ void main()
  304. ▐     {
  305. ▐     int gdriver = DETECT, gmode;           // Standart BGI initialization
  306. ▐     initgraph(&gdriver, &gmode, "");       // see Borland help system
  307. ▐
  308. ▐     KH_Paint* paint = new KH_Paint();      // Create new KH_Paint class
  309. ▐     paint->load("euro.chr");               // Load BGI font
  310. ▐     setcolor(LIGHTRED);
  311. ▐     setfillstyle(SOLID_FILL, LIGHTGRAY);
  312. ▐     paint->set_fill(ON);                   // This flag acts on drawpoly
  313. ▐                        // but not to fonts filling.
  314. ▐     paint->set_zoom(0.5, 0.8);             // Set picture deformation
  315. ▐
  316. ▐     for(int i = 0; i < 360; i += 15)       // BGI fonts output with rotation
  317. ▐     {
  318. ▐     paint->rotate(loc(400, 200), i);
  319. ▐     paint->outtextxy(10, 200, "Hello, World !");
  320. ▐     }
  321. ▐
  322. ▐     cleardevice();
  323. ▐
  324. ▐     for(int i1 = 0; i1 < 360; i1 += 15)    // Primitives output with rotation
  325. ▐     {
  326. ▐     paint->rotate(loc(400, 200), i1);
  327. ▐     paint->roundrect(300, 100, 400, 200, 20);
  328. ▐     int poly[10] = {100, 100, 200, 100, 200, 200, 100, 200, 100, 100};
  329. ▐     paint->drawpoly(5, poly);
  330. ▐     }
  331. ▐
  332. ▐     cleardevice();
  333. ▐     paint->set_stack(ON);                  // Switch complex rotations ON
  334. ▐     for(i = 0; i < 360; i += 30)           // First call rotate image to 30,
  335. ▐     {                                  // second to 60 and so on.
  336. ▐     paint->rotate(loc(400, 200), 30);
  337. ▐     paint->outtextxy(10, 200, "Hello, World !");
  338. ▐     }
  339. ▐
  340. ▐     paint->set_stack(OFF);
  341. ▐     for(int j = 0; j < 360; j += 15)
  342. ▐     {
  343. ▐     paint->rotate(loc(400, 200), j);            // Ellipse rotations
  344. ▐     paint->ellipse(200, 200, 0, 360, 30, 20);
  345. ▐     paint->ellipse(300, 200, 50, 120, 30, 20);
  346. ▐     }
  347. ▐
  348. ▐     delete paint;
  349. ▐     closegraph();
  350. ▐     }
  351.